
// 函数的类型

const sum:(a:any,b:any) => any = function(a:string,b){
    return a+b
}

const sum2:{(a:any, b:any):any} = function(a,b){
    return a+b
}

// sum2进阶
type ISum1 = {(a:any, b:any) : any}
type ISum2 = (a:any, b:any) => any
const sum3:ISum2 = function(a,b){
    return a+b
}

//参数  可选,而且可选必须放在后面
const sum4 = function(a:string, b?:string){
    return a+b
}
sum4('1',undefined)

// 函数式编程和组合式API不是一个东西,前者入参和返回值一定是相同的,后者不一定.可以没有入参
// 求和
function sum5(...args:number[]){
    return args.reduce((memo,current)=>(memo += current,memo),0)
}

// 声明式函数
// function add(x,y){
//     return x+y
// }

// 给上面的函数增加类型
// Ts函数类型后面加:number 不是多此一举,比如，如果函数内部有多个返回路径，或者逻辑比较复杂，手动注解可以确保返回类型符合预期，避免推断错误,然后是防止意外更改。
// 比如，如果函数原本返回number，但后续修改时不小心返回了其他类型，比如字符串，这时候如果有显式返回类型注解，TypeScript会在编译时报错，而如果依赖自动推断，可能不会立即发现问题，直到运行时出错

// function add(x:number,y:number){
function add(x:number,y:number):number{
    console.log('x+y',x+y)
    return x+y
}
add(1,2)

let myAdd: (baseValue: number, increment: number) => number =
    function(x, y) { 
        console.log('myAdd',x+y)
        return x + y; 
    };
    myAdd(2,3)

    // 上面的写法是类型注解和  下面的差不多
    let age11:number = 18;
    let name11:string = '张三';

let name: string = `Gene`;
let age: number = 37;
let sentence: string = `Hello, my name is ${ name }.

I'll be ${ age + 1 } years old next month.`;

// 第二个any是返回值
const sum6:(...args:any[])=> any = (...args:any[]):any =>{}

let x:[string,number];
x = ["hello",10]
console.log(x[0].replace('e','_')); // h_llo

// 剩余参数
const buildName = (firstName:string, ...restOfName:string[])=>{
    return firstName + "" + restOfName.join("")
}
let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");
console.log('employeeName',employeeName);

function toArray(value: string): string[]
function toArray(value: number): number[]
// 上面的声明仅仅是类型的重载

// ts 中函数有一个概念 叫重载(类型的重载), 对于强类型语言可以一个函数写多遍(参数不同)
function toArray(value:string | number):string[] | number[]{
    return []
}
let arr1 = toArray('abc')
let arr2 = toArray(111)
export {}